home *** CD-ROM | disk | FTP | other *** search
/ Developer Helper 1: Phil & Dave's Excellent CD / Excellent CD HFS.raw / Moof / Goodies / HyperCard Goodies / HyperCard Dev. ToolKit / XCMD.Sources / recvString.p < prev    next >
Text File  |  1987-08-26  |  5KB  |  194 lines
  1. {$R-}
  2.  
  3. (*
  4.     recvString(port number, termination character, waitTime, echo, edit,oldString) -- Return a string from the
  5.         serial port; return everything available, up to the termination character (if any). Pass an empty
  6.         termination character to receive everything available. WaitTime is the amount of time to wait
  7.         for the input, in ticks (60ths of a second). Echo is true to enable echoing. Edit is true to enable edit
  8.         characters (i.e., backspace). oldString is what was read the last call (presumably terminated
  9.         due to a time-out).
  10.  
  11.     By Harry Chesley.  DO NOT call the author!  Contact Apple Developer 
  12.     Support on AppleLink "MacDTS" or on MCI "MacTech".
  13.  
  14.     ©Apple Computer, Inc. 1987
  15.     All Rights Reserved.
  16.  
  17.     To compile and link this file using Macintosh Programmer's Workshop,
  18.  
  19.     pascal -w recvString.p
  20.     link -m ENTRYPOINT -o HyperCommands -rt XFCN=0 -sn Main=recvUpTo recvString.p.o "{MPW}"Libraries:interface.o
  21.     
  22. *)
  23.  
  24. {$S recvString }     { Segment name must be the same as the command name. }
  25.  
  26. unit DummyUnit;
  27.  
  28. interface
  29.  
  30. uses MemTypes, QuickDraw, OSIntf, ToolIntf, HyperXCmd;
  31.  
  32. procedure EntryPoint(paramPtr: XCmdPtr);
  33.     
  34. implementation
  35.  
  36. const
  37.  
  38. return = chr(13);
  39. linefeed = chr(10);
  40. bs = chr(8);
  41.  
  42. type
  43.  
  44. Str31 = String[31];
  45.  
  46. procedure recvString(paramPtr: XCmdPtr); forward;
  47.  
  48. procedure EntryPoint(paramPtr: XCmdPtr);
  49.  
  50.     begin
  51.         recvString(paramPtr);
  52.     end;
  53.  
  54. procedure recvString(paramPtr: XCmdPtr);
  55.  
  56.     var portNumber: integer;
  57.         inPort, outPort: integer;
  58.         str: Str255;
  59.         l: longInt;
  60.         waitForChars: longInt;
  61.         lookForTerm: boolean;
  62.         termChar: char;
  63.         echoOn: boolean;
  64.         editOn: boolean;
  65.         linefeedStr: string[1];
  66.         bsStr: string[3];
  67.         resultHand: Handle;
  68.         resultSize: longInt;
  69.         theChar: char;
  70.         p: Ptr;
  71.  
  72.     {$I XCmdGlue.inc}
  73.  
  74.     procedure Fail(errMsg: Str255); { set theResult and quit }
  75.         begin
  76.             paramPtr^.returnValue := PasToZero(errMsg);
  77.             exit(recvString);
  78.         end;
  79.  
  80.     begin
  81.         if paramPtr^.paramCount <> 6 then Fail('parameter count is not 6');
  82.  
  83.         ZeroToPas(paramPtr^.params[1]^,str);        { First parameter is port number. }
  84.         portNumber := StrToNum(str);
  85.         if (portNumber < 1) or (portNumber > 2) then Fail('invalid port number');
  86.         ZeroToPas(paramPtr^.params[2]^,str);        { Second parameter is termination character. }
  87.         if length(str) = 0 then lookForTerm := false
  88.         else
  89.             begin
  90.                 lookForTerm := true;
  91.                 termChar := str[1];
  92.             end;
  93.         ZeroToPas(paramPtr^.params[3]^,str);        { Third parameter is whether to wait. }
  94.         waitForChars := StrToNum(str);
  95.         ZeroToPas(paramPtr^.params[4]^,str);        { Fourth parameter is whether to echo. }
  96.         echoOn := false;
  97.         if length(str) > 0 then
  98.             if (str[1] = 't') or (str[1] = 'T') then echoOn := true;
  99.         ZeroToPas(paramPtr^.params[5]^,str);        { Fifth parameter is whether to edit. }
  100.         editOn := false;
  101.         if length(str) > 0 then
  102.             if (str[1] = 't') or (str[1] = 'T') then editOn := true;
  103.         resultHand := paramPtr^.params[6];            { Sixth parameter is the old string. }
  104.         if resultHand = NIL then Fail('NIL resultHandle!');
  105.         l := GetHandleSize(resultHand);
  106.         p := resultHand^;
  107.         resultSize := 1;
  108.         while resultSize < l do
  109.             begin
  110.                 if p^ = 0 then leave;
  111.                 p := Ptr(ord4(p)+1);
  112.                 resultSize := resultSize + 1;
  113.             end;
  114.         if resultSize < 1 then Fail('Input string size too small!');
  115.         if HandToHand(resultHand) <> noErr then Fail('HandToHand failed!');
  116.         resultSize := resultSize-1;
  117.         SetHandleSize(resultHand,resultSize);
  118.  
  119.         if portNumber = 1 then
  120.             begin
  121.                 inPort := -6;
  122.                 outPort := -7;
  123.             end
  124.         else
  125.             begin
  126.                 inPort := -8;
  127.                 outPort := -9;
  128.             end;
  129.         linefeedStr[0] := chr(1); linefeedStr[1] := linefeed;
  130.         bsStr := '   '; bsStr[1] := bs; bsStr[3] := bs;
  131.         waitForChars := waitForChars + TickCount;
  132.         while TickCount <= waitForChars do
  133.             begin
  134.                 if SerGetBuf(inPort,l) <> noErr then
  135.                     begin
  136.                         DisposHandle(resultHand);
  137.                         Fail('SerGetBuf failed');
  138.                     end;
  139.                 if l = 0 then cycle;
  140.                 l := 1;
  141.                 resultSize := resultSize+1;
  142.                 SetHandleSize(resultHand,resultSize);
  143.                 if MemError <> noErr then
  144.                     begin
  145.                         DisposHandle(resultHand);
  146.                         Fail('SetHandleSize failed!');
  147.                     end;
  148.                 HLock(resultHand);
  149.                 if FSRead(inPort,l,Ptr(ord4(resultHand^)+resultSize-1)) <> noErr then
  150.                     begin
  151.                         DisposHandle(resultHand);
  152.                         Fail('FSRead failed');
  153.                     end;
  154.                 HUnlock(resultHand);
  155.                 p := Ptr(ord4(resultHand^)+resultSize-1);
  156.                 p^ := BAND(p^,$7F);
  157.                 theChar := chr(p^);
  158.                 if echoOn then
  159.                     begin
  160.                         l := 1;
  161.                         if FSWrite(outPort,l,Ptr(ord4(resultHand^)+resultSize-1)) <> noErr then
  162.                             Fail('FSWriter failed');
  163.                         if theChar = return then
  164.                             begin
  165.                                 l := length(linefeedStr);
  166.                                 if FSWrite(outPort,l,Ptr(ord4(@linefeedStr)+1)) <> noErr then Fail('FSWrite failed');
  167.                             end;
  168.                         if editOn and (theChar = bs) then
  169.                             begin
  170.                                 l := length(bsStr);
  171.                                 if FSWrite(outPort,l,Ptr(ord4(@bsStr)+1)) <> noErr then Fail('FSWrite failed');
  172.                             end;
  173.                     end;
  174.                 if editOn then
  175.                     begin
  176.                         if theChar = bs then
  177.                             begin
  178.                                 resultSize := resultSize-2;
  179.                                 if resultSize < 0 then resultSize := 0;
  180.                                 SetHandleSize(resultHand,resultSize);
  181.                             end;
  182.                     end;
  183.                 if lookForTerm then
  184.                     if theChar = termChar then leave;
  185.                 if resultSize > 30000 then leave;
  186.             end;
  187.         SetHandleSize(resultHand,resultSize+1);
  188.         p := ptr(ord4(resultHand^)+resultSize);
  189.         p^ := 0;
  190.         paramPtr^.returnValue := resultHand;
  191.     end;
  192.  
  193. end.
  194.